#!/usr/bin/env python
# coding: utf-8

# In[1]:


python_point={
    "if 语句":{
        '理解意义，100（100）',
        '具体操作,100(95)'
        # if xxxxx :
        # elif xxxxx:
        # else:
    },


# In[ ]:


"for循环以及range内置函数":{
        "单for循环":['理解意义，100（100）','具体操作,100(100)'],
        "range函数学习":['range(stop),理解,100(100),操作,100(90)',
                        'range(start,stop,step),理解,100(100),操作,100(90)'
        ],
        # a=[1,2,3]
        # for b in a:
        # print(b)
        # 1 2 3
        # start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
        # stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
        # step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
        "for循环与range结合":['理解意义，100（90）','具体操作,100(90)']
        # 从1加到10
        # sum=0
        # for a in range(1,11):
        # sum+=a
        # print(sum)
        # 55
        ## for a in range(5)
        ## print('1'
        ## 1 1 1 1 1
    },


# In[ ]:


"random函数学习":{
        'random.random()':['理解意义，100（100）','具体操作,100(100)'],
        # 随机生成一个大于0小于1的随机数。
        #import random
        # a=random.random()
        # print(a)
        # 0.40116812970725435
        'random.uniform(a,b)': ['理解意义，100（100）', '具体操作,100(100)'],
        # 用于生成一个指定范围内的随机浮点数，两个参数其中一个是下限一个是上限。（a<b）
        # import random
        # a=random.uniform(1,2)
        # print(a)
        # 1.6743756738162934
        'random.randint(a,b)': ['理解意义，100（100）', '具体操作,100(100)'],
        # 用于生成一个指定范围内的整数，（a<=N<=b）
        # import random
        # a=random.randint(1,2)
        # print(a)
        # 1 or 2
        'random.randrange([start], stop[, step])': ['理解意义，100（100）', '具体操作,100(90)'],
        # 从指定范围内，按指定的基数递增的集合中获取一个随机数
        #  # import random
        # a=random.randrange(0,10,2)
        # print(a)
        # 0 or 2 or 4 or 6 or 8
        'random.choice(sequence)': ['理解意义，100（100）', '具体操作,100(90)'],
        # 参数sequence表示一个有序类型，从序列中获取一个随机元素
        # import random
        # a=random.choice('123abc')
        # print(a)
        # 1 or 2 or 3 or a or b or c
        'random.shuffle(x[, random])': ['理解意义，100（100）', '具体操作,100(0)'],  # 没有练习过该方法
        # 用于将一个列表中的元素打乱，即将列表内的元素随机排列。
        'random.sample(sequence, k)': ['理解意义，100（80）', '具体操作,100(0)'],  # 没有练习过该方法
        # 从指定的序列中随机获取指定长度的片断并随机排列，sample函数不会修改原有序列

    }
}


# In[ ]:


python_point02={
    '所涉及的字符串内容':{
        '字符串的合并':['理解意义，100（100）','具体操作,100(90)'],
        "''.join()":['理解意义，100（90）','具体操作,100(80)'],
        # 用于字符串的拼接
        # a='123'
        # b=''.join(a)
        # print(b)
        # 123
        'str.split（）':['理解意义，100（90）','具体操作,100(80)'],
        # 用于对字符串进行拆分
        # a='1,2,3'
        # b=a.split(',')
        # print(b)
        # ['1','2','3']
        'str.count()':['理解意义，100（100）','具体操作,100(90)'],
        # 计算字符串某个数值出现的次数
        # a='1,2,3,1'
        # print(a.count('1'))
        # 2
        'str.isdigit':['理解意义，100（100）','具体操作,100(90)'],
        # 如果字符串只包含数字则返回 True，否则返回 False。
        # a='123'
        # print(a.isdigit)
        # True
    },


# In[ ]:


'列表':{
      '列表切片':'list[start,end,step]''理解意义，100（90）','具体操作,100(85)',
       # a=['1','2','3']
       # b=a[:1:-1]
       # b
       # ['3']
      '列表函数':{
          'len(list)':['理解意义，100（100）','具体操作,100(85)'],
           # 列表元素个数
           # a=['1','2','3']
           # len(a)
           # 3
          'max(list)':['理解意义，100（100）','具体操作,100(80)'],
          # 返回列表元素最大值
          # a=['1','2','3']
          # max(a)
          # 3
          'min(list)':['理解意义，100（100）','具体操作,100(80)'],
          # 返回列表元素最小值
          # a=['1','2','3']
          # min(a)
          # 1
          'list(seq)':['理解意义，100（100）','具体操作,100(70)']
          # 将元组转换为列表
          # a=('1','2','3')
          # print(list(a))
          # ['1','2','3']
       },


# In[ ]:



        '列表方法':{
            'list.append(obj':['理解意义，100（100）','具体操作,100(90)'],
            # 在列表末尾添加新的对象
            # a=['1','2']
            # a.append('3')
            # a
            # ['1','2','3']
            'list.extend(obj)':['理解意义，100（90）','具体操作,100(80)'],
            # 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
            # a=['1']
            # a.extend('23')
            # a
            # a=['1','2','3']
            'list.count(obj)':['理解意义，100（100）','具体操作,100(90)'],
            # 统计某个元素在列表中出现的次数
            # a=[1,2,3]
            # list.count(1)
            # 1
            'list.insert(index,obj)':['理解意义，100（100）','具体操作,100(85)'],
            # 将对象插入列表
            # a=[2,3]
            # a.insert(0,1)
            # a=[1,2,3]
            'list.index(obj)':['理解意义，100（100）','具体操作,100(90)'],
            # 从列表中找出某个值第一个匹配项的索引位置
            # a=[1,2,3]
            # a.index(1)
            # 0
            'list.pop()':['理解意义，100（100）','具体操作,100(85)'],
            # 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
            # a=[1,2,3]
            # a.pop(0)
            # a
            # [1,2]
            'list.remove(obj)':['理解意义，100（100）','具体操作,100(85)'],
            # 移除列表中某个值的第一个匹配项
            # a=[1,2,3]
            # a.remove(1)
            # a
            # [2,3]
            'list.reverse()':['理解意义，100（100）','具体操作,100(85)'],
            # 反向列表中元素
            # a=[1,2,3]
            # a.reverse
            # [3,2,1
            'list.clear()':['理解意义，100（100）','具体操作,100(85)'],
            # 保留列表名称，清空里面的值
            # a=[1,2,3]
            # a.clear()
            # a
            # []
            'list.copy()':['理解意义，100（90）','具体操作,100(85)'],
            # 复制列表
            # a=[1,2,3]
            # b=a.copy()
            # b
            # [1,2,3]
            'list.sort':['理解意义，100（80）','具体操作,100(80)'],
            # 对原列表进行排序
            # a=[2,3,1]
            # a.sort()
            # a
            # [1,2,3]
        },


# In[ ]:


"字典":{
            '对字典的键和键值的理解':"100(100)",
            '访问字典里的值':['理解意义，100（100）','具体操作,100(100)'],
            # dict={'me':hzx}
            # dict['me']
            # hzx
            '修改字典的值':['理解意义，100（100）','具体操作,100(100)'],
            # dict1={'me':hhh}
            # dict1['me']=hzx
            # dict1
            # hzx
            '删除字典元素':['理解意义，100（100）','具体操作,100(90)'],
            # dict1={'me':1}
            # del dict1
            # dict1={}
            "字典的内置函数":{
                'len(dict)':['理解意义，100（100）','具体操作,100(90)'],
                # 计算字典元素个数，即键的总数。
                # dict1={'1','2','3'}
                # len(dict1)
                # 3
                'str(dict)':['理解意义，100（100）','具体操作,100(90)'],
                # 输出字典可打印的字符串表示。
                # dict1={'1','2','3'}
                # str=str(dict1)
                # '{'1','2','3'}'
                },
            '字典的内置方法':{
                'dict.clear()':['理解意义，100（100）','具体操作,100(90)'],
                # 删除字典内所有元素
                # score={'语文':95,'数学':90}
                # score.clear()
                # print(score)
                # 输出结果{}
                'dict.copy()':['理解意义，100（100）','具体操作,100(90)'],
                # 返回一个字典的浅复制
                # a={'语文':95,'数学':90}
                # dict.copy(a)
                # dict
                # {'语文':95,'数学':90}
                'dict.get(key, default=None)':['理解意义，100（90）','具体操作,100(80)'],
                # 返回指定键的值，如果值不在字典中返回default值
                # score={'语文':95,'数学':90}
                # score['语文']
                # 95
                # score['python']
                # default
                'dict.items()':['理解意义，100（90）','具体操作,100(85)'],
                # 以列表返回可遍历的(键, 值) 元组数组
                # score={'语文':95,'数学':90}
                # score.items()
                # '语文':95,'数学':90
                'dict.keys()':['理解意义，100（90）','具体操作,100(90)'],
                # 以列表返回一个字典所有的键
                # score={'语文':95,'数学':90}
                # score.keys()
                # dict_keys(['语文', '数学'])
                'dict.setdefault(key, default=None)':['理解意义，100（90）','具体操作,100(90)'],
                # 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
                # score={}
                # score.setdefault['语文']=95
                # score.setdefault['数学']=90
                # score
                # score={'语文':95,'数学':90}
                'dict.values()':['理解意义，100（90）','具体操作,100(90)'],
                # 以列表返回字典中的所有值
                # score={'语文':95,'数学':90}
                # score.values()
                # dict_values([95,90])
                'dict.update(dict2)':['理解意义，100（80）','具体操作,100(75)'],
                # 把字典dict2的键/值对更新到dict里
                # score={"语文":95}
                # score2={'数学':90}
                # score.update(score2)
                # print(score)
                'pop(key[,default])':['理解意义，100（90）','具体操作,100(80)'],
                # 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
                # score={'语文':95,'数学':90}
                # score.pop('数学')
                # print(score)
                # {'语文':95}
                # score={'语文':95}
                'popitem()':['理解意义，100（90）','具体操作,100(80)'],
                # 返回并删除字典中的最后一对键和值。
                # score={'语文':95,'数学':90}
                # score.popitem()
                # print(score)
                # {'语文':95}
                # score={'语文':95}
            }
        },


# In[ ]:


"集合":{
       '集合的方法':{
'set.add()':['理解意义，100（100）','具体操作,100(90)'],
       # 为集合添加元素
       # set1 = {1, 2, 3}
       # set1.add((1, 2))
       # print(set1)
       # 输出结果{(1, 2), 1, 2, 3}
       'set.clear()':['理解意义，100（90）','具体操作,100(80)'],
       # 移除集合中的所有元素
       # set1 = {1,2,3}
       # set1.clear()
       # print(set1)
       #输出结果set()
       'set.copy()':['理解意义，100（100）','具体操作,100(90)'],
       # 拷贝一个集合
       # set1 = {1,2,3}
       # set1.clear()
       # print(set1)
       #输出结果set()
       'set.difference()':['理解意义，100（80）','具体操作,100(80)'],
       # 返回多个集合的差集
       # set1 = {1,2,3}
       # set2 = {3,4}
       # set3 = set1.difference(set2)
       # print(set3)
       # 输出结果皆为{1, 2}
       'set.discard()':['理解意义，100（100）','具体操作,100(80)'],
       # 	删除集合中指定的元素
       # set1 = {1,2,3}
       # set1.discard(2)
       # print(set1)
       # #输出结果{1, 3}
       'set.intersection()':['理解意义，100（80）','具体操作,100(80)'],
       # 返回集合的交集
       # set1 = {1,2,3}
       # set2 = {3,4}
       # set3 = set1.intersection(set2)
       # print(set3)
       # 最后输出结果皆为{3}
       'set.isdisjoint()':['理解意义，100（80）','具体操作,100(80)'],
       # 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
       # set1 = {1,2,3}
       # set2 = {3,4}
       # print(set1.isdisjoint(set2))
       # False
       'set.pop()':['理解意义，100（100）','具体操作,100(90)'],
       # 	随机移除元素(默认是最后一个元素)
       # set1 = {1,2,3}
       # a = set1.pop()
       # print(set1)
       # #{2,3}
       # print(a)
       # 1
       'set.symmetric_difference()':['理解意义，100（80）','具体操作,100(80)'],
       # 	返回两个集合中不重复的元素集合。
       # set1 = {1,2,3}
       # set2 = {3,4}
       # set3 = set1.symmetric_difference(set2)
       # print(set3)
       # {1, 2, 4}
       'set.union()':['理解意义，100（80）','具体操作,100(80)'],
       # 	返回两个集合的并集
       # set1 = {1,2,3}
       # set2 = {3,4}
       # set3=set1.union(set2)
       # print(set3)
       # {1, 2, 3, 4}
       }
   }
}


# In[ ]:


python_point03={
    '函数的初步学习':{
        '函数关键字def return':['理解意义，100（90）','具体操作,100(80)'],
        '函数两种添加注释方法':['理解意义，100（90）','具体操作,100(90)'],
        # 方法一’‘’str‘’‘  方法二 #
        '函数的*args用法':['理解意义，100（80）','具体操作,100(80)'],
        # 传入多个参数，转化成元组
        '函数的**kwargs用法':['理解意义，100（80）','具体操作,100(80)'],
        # 把关键字参数，转化成字典
        '函数的调用 import':['理解意义，100（100）','具体操作,100(90)'],
        '函数的as用法':['理解意义，100（100）','具体操作,100(90)'],
        '从模块中导入函数':['理解意义，100（90）','具体操作,100(80)'],
    }
}

